home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python1.4_Source / Objects / abstract.c next >
C/C++ Source or Header  |  1998-06-24  |  23KB  |  1,097 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Abstract Object Interface (many thanks to Jim Fulton) */
  33.  
  34. #include "Python.h"
  35.  
  36. #include "protos/abstract_protos.h"
  37.  
  38. #define Py_TRY(E) if(!(E)) return NULL
  39. #define Py_ASSERT(EXP,E,V) if(!(EXP)) return PyErr_SetString(E,V), (void*)NULL
  40. #define SPAM printf("line %d\n",__LINE__)
  41.  
  42. static PyObject *
  43. Py_ReturnMethodError(name)
  44.   char *name;
  45. {
  46.   if(! name) name = "Unknown Error";
  47.   PyErr_SetString(PyExc_AttributeError,name);
  48.   return 0;
  49. }
  50.  
  51. PyObject *
  52. Py_ReturnNullError Py_PROTO((void))
  53. {
  54.   if(! PyErr_Occurred())
  55.     PyErr_SetString(PyExc_SystemError,
  56.             "null argument to internal routine");
  57.   return 0;
  58. }
  59.  
  60. int 
  61. PyObject_Cmp(o1, o2, result)
  62.   PyObject *o1;
  63.   PyObject *o2;
  64.   int *result;
  65. {
  66.   int r;
  67.  
  68.   if(! o1 || ! o2) return Py_ReturnNullError(),-1;
  69.   r=PyObject_Compare(o1,o2);
  70.   if(PyErr_Occurred()) return -1;
  71.   *result=r;
  72.   return 0;
  73. }
  74.  
  75. #if 0 /* Already in object.c */
  76. int
  77. PyCallable_Check(x)
  78.   PyObject *x;
  79. {
  80.     if (x == NULL)
  81.         return 0;
  82.     if (x->ob_type->tp_call != NULL ||
  83.         PyFunction_Check(x) ||
  84.         PyMethod_Check(x) ||
  85.         PyCFunction_Check(x) ||
  86.         PyClass_Check(x))
  87.         return 1;
  88.     if (PyInstance_Check(x)) {
  89.         PyObject *call = PyObject_GetAttrString(x, "__call__");
  90.         if (call == NULL) {
  91.             PyErr_Clear();
  92.             return 0;
  93.         }
  94.         /* Could test recursively but don't, for fear of endless
  95.            recursion if some joker sets self.__call__ = self */
  96.         Py_DECREF(call);
  97.         return 1;
  98.     }
  99.     return 0;
  100. }
  101. #endif
  102.  
  103. PyObject *
  104. PyObject_Type(o)
  105.     PyObject *o;
  106. {
  107.     PyObject *v;
  108.  
  109.     if(! o) return Py_ReturnNullError();
  110.     v = (PyObject *)o->ob_type;
  111.     Py_INCREF(v);
  112.     return v;
  113. }
  114.  
  115. int
  116. PyObject_Length(o)
  117.   PyObject *o;
  118. {
  119.   PySequenceMethods *m;
  120.  
  121.   if(! o) return Py_ReturnNullError(),-1;
  122.  
  123.   if((m=o->ob_type->tp_as_sequence) && m->sq_length)
  124.     return m->sq_length(o);
  125.  
  126.   return PyMapping_Length(o);
  127. }
  128.  
  129. PyObject *
  130. PyObject_GetItem(o, key)
  131.   PyObject *o;
  132.   PyObject *key;
  133. {
  134.   PyMappingMethods *m;
  135.  
  136.   if(! o || ! key) return Py_ReturnNullError();
  137.  
  138.   if((m=o->ob_type->tp_as_mapping) && m->mp_subscript)
  139.     return m->mp_subscript(o,key);
  140.   
  141.   if(PyInt_Check(key))
  142.     return PySequence_GetItem(o,PyInt_AsLong(key));
  143.  
  144.   PyErr_SetString(PyExc_TypeError,"expected integer index");
  145.   return NULL;
  146. }
  147.  
  148. int
  149. PyObject_SetItem(o, key, value)
  150.   PyObject *o;
  151.   PyObject *key;
  152.   PyObject *value;
  153. {
  154.   PyMappingMethods *m;
  155.  
  156.   if(! o || ! key || ! value) return Py_ReturnNullError(),-1;
  157.   if((m=o->ob_type->tp_as_mapping) && m->mp_ass_subscript)
  158.     return m->mp_ass_subscript(o,key,value);
  159.   
  160.   if(PyInt_Check(key))
  161.     return PySequence_SetItem(o,PyInt_AsLong(key),value);
  162.  
  163.   PyErr_SetString(PyExc_TypeError,"expeced integer index");
  164.   return -1;
  165. }
  166.  
  167. int
  168. PyObject_DelItem(o, key)
  169.   PyObject *o;
  170.   PyObject *key;
  171. {
  172.   PyMappingMethods *m;
  173.  
  174.   if(! o || ! key) return Py_ReturnNullError(),-1;
  175.   if((m=o->ob_type->tp_as_mapping) && m->mp_ass_subscript)
  176.     return m->mp_ass_subscript(o,key,(PyObject*)NULL);
  177.   
  178.   if(PyInt_Check(key))
  179.     return PySequence_SetItem(o,PyInt_AsLong(key),(PyObject*)NULL);
  180.  
  181.   PyErr_SetString(PyExc_TypeError,"expeced integer index");
  182.   return -1;
  183. }
  184.  
  185. int 
  186. PyNumber_Check(o)
  187.   PyObject *o;
  188. {
  189.   return o && o->ob_type->tp_as_number;
  190. }
  191.  
  192.  
  193. #define BINOP(opname, ropname, thisfunc) \
  194.     if (!PyInstance_Check(v) && !PyInstance_Check(w)) \
  195.         ; \
  196.     else \
  197.         return PyInstance_DoBinOp(v, w, opname, ropname, thisfunc)
  198.  
  199. PyObject *
  200. PyNumber_Or(v, w)
  201.     PyObject *v, *w;
  202. {
  203.         extern int PyNumber_Coerce();
  204.  
  205.     BINOP("__or__", "__ror__", PyNumber_Or);
  206.     if (v->ob_type->tp_as_number != NULL) {
  207.         PyObject *x;
  208.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  209.         if (PyNumber_Coerce(&v, &w) != 0)
  210.             return NULL;
  211.         if ((f = v->ob_type->tp_as_number->nb_or) != NULL)
  212.             x = (*f)(v, w);
  213.         Py_DECREF(v);
  214.         Py_DECREF(w);
  215.         if (f != NULL)
  216.             return x;
  217.     }
  218.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for |");
  219.     return NULL;
  220. }
  221.  
  222. PyObject *
  223. PyNumber_Xor(v, w)
  224.     PyObject *v, *w;
  225. {
  226.         extern int PyNumber_Coerce();
  227.  
  228.     BINOP("__xor__", "__rxor__", PyNumber_Xor);
  229.     if (v->ob_type->tp_as_number != NULL) {
  230.         PyObject *x;
  231.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  232.         if (PyNumber_Coerce(&v, &w) != 0)
  233.             return NULL;
  234.         if ((f = v->ob_type->tp_as_number->nb_xor) != NULL)
  235.             x = (*f)(v, w);
  236.         Py_DECREF(v);
  237.         Py_DECREF(w);
  238.         if (f != NULL)
  239.             return x;
  240.     }
  241.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for ^");
  242.     return NULL;
  243. }
  244.  
  245. PyObject *
  246. PyNumber_And(v, w)
  247.     PyObject *v, *w;
  248. {
  249.     BINOP("__and__", "__rand__", PyNumber_And);
  250.     if (v->ob_type->tp_as_number != NULL) {
  251.         PyObject *x;
  252.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  253.         if (PyNumber_Coerce(&v, &w) != 0)
  254.             return NULL;
  255.         if ((f = v->ob_type->tp_as_number->nb_and) != NULL)
  256.             x = (*f)(v, w);
  257.         Py_DECREF(v);
  258.         Py_DECREF(w);
  259.         if (f != NULL)
  260.             return x;
  261.     }
  262.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for &");
  263.     return NULL;
  264. }
  265.  
  266. PyObject *
  267. PyNumber_Lshift(v, w)
  268.     PyObject *v, *w;
  269. {
  270.     BINOP("__lshift__", "__rlshift__", PyNumber_Lshift);
  271.     if (v->ob_type->tp_as_number != NULL) {
  272.         PyObject *x;
  273.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  274.         if (PyNumber_Coerce(&v, &w) != 0)
  275.             return NULL;
  276.         if ((f = v->ob_type->tp_as_number->nb_lshift) != NULL)
  277.             x = (*f)(v, w);
  278.         Py_DECREF(v);
  279.         Py_DECREF(w);
  280.         if (f != NULL)
  281.             return x;
  282.     }
  283.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for <<");
  284.     return NULL;
  285. }
  286.  
  287. PyObject *
  288. PyNumber_Rshift(v, w)
  289.     PyObject *v, *w;
  290. {
  291.     BINOP("__rshift__", "__rrshift__", PyNumber_Rshift);
  292.     if (v->ob_type->tp_as_number != NULL) {
  293.         PyObject *x;
  294.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  295.         if (PyNumber_Coerce(&v, &w) != 0)
  296.             return NULL;
  297.         if ((f = v->ob_type->tp_as_number->nb_rshift) != NULL)
  298.             x = (*f)(v, w);
  299.         Py_DECREF(v);
  300.         Py_DECREF(w);
  301.         if (f != NULL)
  302.             return x;
  303.     }
  304.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for >>");
  305.     return NULL;
  306. }
  307.  
  308. PyObject *
  309. PyNumber_Add(v, w)
  310.     PyObject *v, *w;
  311. {
  312.     BINOP("__add__", "__radd__", PyNumber_Add);
  313.     if (v->ob_type->tp_as_sequence != NULL)
  314.         return (*v->ob_type->tp_as_sequence->sq_concat)(v, w);
  315.     else if (v->ob_type->tp_as_number != NULL) {
  316.         PyObject *x;
  317.         if (PyNumber_Coerce(&v, &w) != 0)
  318.             return NULL;
  319.         x = (*v->ob_type->tp_as_number->nb_add)(v, w);
  320.         Py_DECREF(v);
  321.         Py_DECREF(w);
  322.         return x;
  323.     }
  324.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for +");
  325.     return NULL;
  326. }
  327.  
  328. PyObject *
  329. PyNumber_Subtract(v, w)
  330.     PyObject *v, *w;
  331. {
  332.     BINOP("__sub__", "__rsub__", PyNumber_Subtract);
  333.     if (v->ob_type->tp_as_number != NULL) {
  334.         PyObject *x;
  335.         if (PyNumber_Coerce(&v, &w) != 0)
  336.             return NULL;
  337.         x = (*v->ob_type->tp_as_number->nb_subtract)(v, w);
  338.         Py_DECREF(v);
  339.         Py_DECREF(w);
  340.         return x;
  341.     }
  342.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for -");
  343.     return NULL;
  344. }
  345.  
  346. PyObject *
  347. PyNumber_Multiply(v, w)
  348.     PyObject *v, *w;
  349. {
  350.     PyTypeObject *tp;
  351.     tp = v->ob_type;
  352.     BINOP("__mul__", "__rmul__", PyNumber_Multiply);
  353.     if (tp->tp_as_number != NULL &&
  354.         w->ob_type->tp_as_sequence != NULL &&
  355.         !PyInstance_Check(v)) {
  356.         /* number*sequence -- swap v and w */
  357.         PyObject *tmp = v;
  358.         v = w;
  359.         w = tmp;
  360.         tp = v->ob_type;
  361.     }
  362.     if (tp->tp_as_number != NULL) {
  363.         PyObject *x;
  364.         if (PyInstance_Check(v)) {
  365.             /* Instances of user-defined classes get their
  366.                other argument uncoerced, so they may
  367.                implement sequence*number as well as
  368.                number*number. */
  369.             Py_INCREF(v);
  370.             Py_INCREF(w);
  371.         }
  372.         else if (PyNumber_Coerce(&v, &w) != 0)
  373.             return NULL;
  374.         x = (*v->ob_type->tp_as_number->nb_multiply)(v, w);
  375.         Py_DECREF(v);
  376.         Py_DECREF(w);
  377.         return x;
  378.     }
  379.     if (tp->tp_as_sequence != NULL) {
  380.         if (!PyInt_Check(w)) {
  381.             PyErr_SetString(PyExc_TypeError,
  382.                 "can't multiply sequence with non-int");
  383.             return NULL;
  384.         }
  385.         return (*tp->tp_as_sequence->sq_repeat)
  386.                         (v, (int)PyInt_AsLong(w));
  387.     }
  388.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for *");
  389.     return NULL;
  390. }
  391.  
  392. PyObject *
  393. PyNumber_Divide(v, w)
  394.     PyObject *v, *w;
  395. {
  396.     BINOP("__div__", "__rdiv__", PyNumber_Divide);
  397.     if (v->ob_type->tp_as_number != NULL) {
  398.         PyObject *x;
  399.         if (PyNumber_Coerce(&v, &w) != 0)
  400.             return NULL;
  401.         x = (*v->ob_type->tp_as_number->nb_divide)(v, w);
  402.         Py_DECREF(v);
  403.         Py_DECREF(w);
  404.         return x;
  405.     }
  406.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for /");
  407.     return NULL;
  408. }
  409.  
  410. PyObject *
  411. PyNumber_Remainder(v, w)
  412.     PyObject *v, *w;
  413. {
  414.     if (PyString_Check(v)) {
  415.         return PyString_Format(v, w);
  416.     }
  417.     BINOP("__mod__", "__rmod__", PyNumber_Remainder);
  418.     if (v->ob_type->tp_as_number != NULL) {
  419.         PyObject *x;
  420.         if (PyNumber_Coerce(&v, &w) != 0)
  421.             return NULL;
  422.         x = (*v->ob_type->tp_as_number->nb_remainder)(v, w);
  423.         Py_DECREF(v);
  424.         Py_DECREF(w);
  425.         return x;
  426.     }
  427.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for %");
  428.     return NULL;
  429. }
  430.  
  431. PyObject *
  432. PyNumber_Divmod(v, w)
  433.     PyObject *v, *w;
  434. {
  435.     PyObject *res;
  436.  
  437.     if (PyInstance_Check(v) || PyInstance_Check(w))
  438.         return PyInstance_DoBinOp(v, w, "__divmod__", "__rdivmod__",
  439.                      PyNumber_Divmod);
  440.     if (v->ob_type->tp_as_number == NULL ||
  441.                 w->ob_type->tp_as_number == NULL) {
  442.         PyErr_SetString(PyExc_TypeError,
  443.             "divmod() requires numeric or class instance arguments");
  444.         return NULL;
  445.     }
  446.     if (PyNumber_Coerce(&v, &w) != 0)
  447.         return NULL;
  448.     res = (*v->ob_type->tp_as_number->nb_divmod)(v, w);
  449.     Py_DECREF(v);
  450.     Py_DECREF(w);
  451.     return res;
  452. }
  453.  
  454.  
  455. static PyObject *
  456. do_pow(v, w)
  457.     PyObject *v, *w;
  458. {
  459.     PyObject *res;
  460.     if (PyInstance_Check(v) || PyInstance_Check(w))
  461.         return PyInstance_DoBinOp(v, w, "__pow__", "__rpow__", do_pow);
  462.     if (v->ob_type->tp_as_number == NULL ||
  463.         w->ob_type->tp_as_number == NULL) {
  464.         PyErr_SetString(PyExc_TypeError,
  465.                 "pow() requires numeric arguments");
  466.         return NULL;
  467.     }
  468.     if (PyFloat_Check(w) && PyFloat_AsDouble(v) < 0.0) {
  469.         if (!PyErr_Occurred())
  470.             PyErr_SetString(PyExc_ValueError,
  471.                     "negative number to float power");
  472.         return NULL;
  473.     }
  474.     if (PyNumber_Coerce(&v, &w) != 0)
  475.         return NULL;
  476.     res = (*v->ob_type->tp_as_number->nb_power)(v, w, Py_None);
  477.     Py_DECREF(v);
  478.     Py_DECREF(w);
  479.     return res;
  480. }
  481.  
  482. PyObject *
  483. PyNumber_Power(v,w,z)
  484.     PyObject *v, *w, *z;
  485. {
  486.     PyObject *res;
  487.     PyObject *v1, *z1, *w2, *z2;
  488.  
  489.     if (z == Py_None)
  490.         return do_pow(v, w);
  491.     /* XXX The ternary version doesn't do class instance coercions */
  492.     if (PyInstance_Check(v))
  493.         return v->ob_type->tp_as_number->nb_power(v, w, z);
  494.     if (v->ob_type->tp_as_number == NULL ||
  495.         z->ob_type->tp_as_number == NULL ||
  496.         w->ob_type->tp_as_number == NULL) {
  497.         PyErr_SetString(PyExc_TypeError, "pow() requires numeric arguments");
  498.         return NULL;
  499.     }
  500.     if (PyNumber_Coerce(&v, &w) != 0)
  501.         return NULL;
  502.     res = NULL;
  503.     v1 = v;
  504.     z1 = z;
  505.     if (PyNumber_Coerce(&v1, &z1) != 0)
  506.         goto error2;
  507.     w2 = w;
  508.     z2 = z1;
  509.      if (PyNumber_Coerce(&w2, &z2) != 0)
  510.         goto error1;
  511.     res = (*v1->ob_type->tp_as_number->nb_power)(v1, w2, z2);
  512.     Py_DECREF(w2);
  513.     Py_DECREF(z2);
  514.  error1:
  515.     Py_DECREF(v1);
  516.     Py_DECREF(z1);
  517.  error2:
  518.     Py_DECREF(v);
  519.     Py_DECREF(w);
  520.     return res;
  521. }
  522.  
  523.  
  524. PyObject *
  525. PyNumber_Negative(v)
  526.     PyObject *v;
  527. {
  528.     if (v->ob_type->tp_as_number != NULL)
  529.         return (*v->ob_type->tp_as_number->nb_negative)(v);
  530.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary -");
  531.     return NULL;
  532. }
  533.  
  534. PyObject *
  535. PyNumber_Positive(v)
  536.     PyObject *v;
  537. {
  538.     if (v->ob_type->tp_as_number != NULL)
  539.         return (*v->ob_type->tp_as_number->nb_positive)(v);
  540.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary +");
  541.     return NULL;
  542. }
  543.  
  544. PyObject *
  545. PyNumber_Invert(v)
  546.     PyObject *v;
  547. {
  548.     PyObject * (*f) Py_FPROTO((PyObject *));
  549.     if (v->ob_type->tp_as_number != NULL &&
  550.         (f = v->ob_type->tp_as_number->nb_invert) != NULL)
  551.         return (*f)(v);
  552.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary ~");
  553.     return NULL;
  554. }
  555.  
  556. PyObject *
  557. PyNumber_Absolute(o)
  558.   PyObject *o;
  559. {
  560.   PyNumberMethods *m;
  561.  
  562.   if(! o) return Py_ReturnNullError();
  563.   if((m=o->ob_type->tp_as_number) && m->nb_absolute)
  564.     return m->nb_absolute(o);
  565.  
  566.   return Py_ReturnMethodError("__abs__");  
  567. }
  568.  
  569. PyObject *
  570. PyNumber_Int(o)
  571.   PyObject *o;
  572. {
  573.   PyNumberMethods *m;
  574.  
  575.   if(! o) return Py_ReturnNullError();
  576.   if((m=o->ob_type->tp_as_number) && m->nb_int)
  577.     return m->nb_int(o);
  578.  
  579.   return Py_ReturnMethodError("__int__");  
  580. }
  581.  
  582. PyObject *
  583. PyNumber_Long(o)
  584.   PyObject *o;
  585. {
  586.   PyNumberMethods *m;
  587.  
  588.   if(! o) return Py_ReturnNullError();
  589.   if((m=o->ob_type->tp_as_number) && m->nb_long)
  590.     return m->nb_long(o);
  591.  
  592.   return Py_ReturnMethodError("__long__");  
  593. }
  594.  
  595. PyObject *
  596. PyNumber_Float(o)
  597.   PyObject *o;
  598. {
  599.   PyNumberMethods *m;
  600.  
  601.   if(! o) return Py_ReturnNullError();
  602.   if((m=o->ob_type->tp_as_number) && m->nb_float)
  603.     return m->nb_float(o);
  604.  
  605.   return Py_ReturnMethodError("__float__");  
  606. }
  607.  
  608.  
  609. int 
  610. PySequence_Check(o)
  611.   PyObject *o;
  612. {
  613.   return o && o->ob_type->tp_as_sequence;
  614. }
  615.  
  616. int 
  617. PySequence_Length(s)
  618.   PyObject *s;
  619. {
  620.   PySequenceMethods *m;
  621.  
  622.   if(! s) return Py_ReturnNullError(),-1;
  623.  
  624.   if((m=s->ob_type->tp_as_sequence) && m->sq_length)
  625.     return m->sq_length(s);
  626.  
  627.   Py_ReturnMethodError("__len__");
  628.   return -1;
  629. }
  630.  
  631. PyObject *
  632. PySequence_Concat(s, o)
  633.   PyObject *s;
  634.   PyObject *o;
  635. {
  636.   PySequenceMethods *m;
  637.  
  638.   if(! s || ! o) return Py_ReturnNullError();
  639.       
  640.   if((m=s->ob_type->tp_as_sequence) && m->sq_concat)
  641.     return m->sq_concat(s,o);
  642.  
  643.   return Py_ReturnMethodError("__concat__");
  644. }
  645.  
  646. PyObject *
  647. PySequence_Repeat(o, count)
  648.   PyObject *o;
  649.   int count;
  650. {
  651.   PySequenceMethods *m;
  652.  
  653.   if(! o) return Py_ReturnNullError();
  654.       
  655.   if((m=o->ob_type->tp_as_sequence) && m->sq_repeat)
  656.     return m->sq_repeat(o,count);
  657.  
  658.   return Py_ReturnMethodError("__repeat__");
  659. }
  660.  
  661. PyObject *
  662. PySequence_GetItem(s, i)
  663.   PyObject *s;
  664.   int i;
  665. {
  666.   PySequenceMethods *m;
  667.   int l;
  668.  
  669.   if(! s) return Py_ReturnNullError();
  670.  
  671.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_item))
  672.     return Py_ReturnMethodError("__getitem__");  
  673.  
  674.   if(0 > (l=m->sq_length(s))) return NULL;
  675.  
  676.   if(i < 0) i += l;
  677.       
  678.   return m->sq_item(s,i);
  679. }
  680.  
  681. PyObject *
  682. PySequence_GetSlice(s, i1, i2)
  683.   PyObject *s;
  684.   int i1;
  685.   int i2;
  686. {
  687.   PySequenceMethods *m;
  688.   int l;
  689.  
  690.   if(! s) return Py_ReturnNullError();
  691.  
  692.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_slice))
  693.     return Py_ReturnMethodError("__getslice__");  
  694.  
  695.   if(0 > (l=m->sq_length(s))) return NULL;
  696.  
  697.   if(i1 < 0) i1 += l;
  698.   if(i2 < 0) i2 += l;
  699.       
  700.   return m->sq_slice(s,i1,i2);
  701. }
  702.  
  703. int
  704. PySequence_SetItem(s, i, o)
  705.   PyObject *s;
  706.   int i;
  707.   PyObject *o;
  708. {
  709.   PySequenceMethods *m;
  710.   int l;
  711.   if(! s) return Py_ReturnNullError(),-1;
  712.  
  713.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_item))
  714.     return Py_ReturnMethodError("__setitem__"),-1;  
  715.  
  716.   if(i < 0)
  717.     {
  718.       if(0 > (l=m->sq_length(s))) return -1;
  719.       i += l;
  720.     }
  721.       
  722.   return m->sq_ass_item(s,i,o);
  723. }
  724.  
  725. int
  726. PySequence_DelItem(s, i)
  727.   PyObject *s;
  728.   int i;
  729. {
  730.   PySequenceMethods *m;
  731.   int l;
  732.   if(! s) return Py_ReturnNullError(),-1;
  733.  
  734.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_item))
  735.     return Py_ReturnMethodError("__delitem__"),-1;  
  736.  
  737.   if(i < 0)
  738.     {
  739.       if(0 > (l=m->sq_length(s))) return -1;
  740.       i += l;
  741.     }
  742.       
  743.   return m->sq_ass_item(s,i,(PyObject*)NULL);
  744. }
  745.  
  746. int 
  747. PySequence_SetSlice(s, i1, i2, o)
  748.   PyObject *s;
  749.   int i1;
  750.   int i2;
  751.   PyObject *o;
  752. {
  753.   PySequenceMethods *m;
  754.   int l;
  755.  
  756.   if(! s) return Py_ReturnNullError(),-1;
  757.  
  758.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_slice))
  759.     return Py_ReturnMethodError("__setslice__"),-1;  
  760.  
  761.   if(0 > (l=m->sq_length(s))) return -1;
  762.  
  763.   if(i1 < 0) i1 += l;
  764.   if(i2 < 0) i2 += l;
  765.       
  766.   return m->sq_ass_slice(s,i1,i2,o);
  767. }
  768.  
  769. int 
  770. PySequence_DelSlice(s, i1, i2)
  771.   PyObject *s;
  772.   int i1;
  773.   int i2;
  774. {
  775.   PySequenceMethods *m;
  776.   int l;
  777.  
  778.   if(! s) return Py_ReturnNullError(),-1;
  779.  
  780.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_slice))
  781.     return Py_ReturnMethodError("__delslice__"),-1;  
  782.  
  783.   if(0 > (l=m->sq_length(s))) return -1;
  784.  
  785.   if(i1 < 0) i1 += l;
  786.   if(i2 < 0) i2 += l;
  787.       
  788.   return m->sq_ass_slice(s,i1,i2,(PyObject*)NULL);
  789. }
  790.  
  791. PyObject *
  792. PySequence_Tuple(s)
  793.   PyObject *s;
  794. {
  795.   int l, i;
  796.   PyObject *t, *item;
  797.  
  798.   if(! s) return Py_ReturnNullError();
  799.  
  800.   Py_TRY((l=PySequence_Length(s)) != -1);
  801.   Py_TRY(t=PyTuple_New(l));
  802.  
  803.   for(i=0; i < l; i++)
  804.     {
  805.       if(item=PySequence_GetItem(s,i))
  806.     {
  807.       if(PyTuple_SetItem(t,i,item) == -1)
  808.         {
  809.           Py_DECREF(item);
  810.           Py_DECREF(t);
  811.           return NULL;
  812.         }
  813.     }
  814.       else
  815.     {
  816.       Py_DECREF(t);
  817.       return NULL;
  818.     }
  819.     }
  820.   return t;
  821. }
  822.  
  823. int 
  824. PySequence_Count(s, o)
  825.   PyObject *s;
  826.   PyObject *o;
  827. {
  828.   int l, i, n=0, not_equal, err;
  829.   PyObject *item;
  830.  
  831.   if(! s || ! o) return Py_ReturnNullError(), -1;
  832.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  833.  
  834.   for(i=0; i < l; i++)
  835.     {
  836.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  837.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  838.       Py_DECREF(item);
  839.       if(err) return -1;
  840.       n += ! not_equal;
  841.     }
  842.   return n;
  843. }
  844.  
  845. int 
  846. PySequence_In(s, o)
  847.   PyObject *s;
  848.   PyObject *o;
  849. {
  850.   int l, i, not_equal, err;
  851.   PyObject *item;
  852.  
  853.   if(! o || ! s) return Py_ReturnNullError(), -1;
  854.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  855.  
  856.   for(i=0; i < l; i++)
  857.     {
  858.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  859.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  860.       Py_DECREF(item);
  861.       if(err) return -1;
  862.       if(! not_equal) return 1;
  863.     }
  864.   return 0;
  865. }
  866.  
  867. int 
  868. PySequence_Index(s, o)
  869.   PyObject *s;
  870.   PyObject *o;
  871. {
  872.   int l, i, n=0, not_equal, err;
  873.   PyObject *item;
  874.  
  875.   if(! s || ! o) return Py_ReturnNullError(), -1;
  876.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  877.  
  878.   for(i=0; i < l; i++)
  879.     {
  880.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  881.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  882.       Py_DECREF(item);
  883.       if(err) return -1;
  884.       if(! not_equal) return n;
  885.     }
  886.   return -1;
  887. }
  888.  
  889. int 
  890. PyMapping_Check(o)
  891.   PyObject *o;
  892. {
  893.   return o && o->ob_type->tp_as_mapping;
  894. }
  895.  
  896. int 
  897. PyMapping_Length(s)
  898.   PyObject *s;
  899. {
  900.   PyMappingMethods *m;
  901.  
  902.   if(! s) return Py_ReturnNullError(),-1;
  903.  
  904.   if((m=s->ob_type->tp_as_mapping) && m->mp_length)
  905.     return m->mp_length(s);
  906.  
  907.   Py_ReturnMethodError("__len__");
  908.   return -1;
  909. }
  910.  
  911. int 
  912. PyMapping_HasKeyString(o, key)
  913.   PyObject *o;
  914.   char *key;
  915. {
  916.   PyObject *v;
  917.  
  918.   v=PyMapping_GetItemString(o,key);
  919.   if(v) return 1;
  920.   PyErr_Clear();
  921.   return 0;
  922. }
  923.  
  924. int 
  925. PyMapping_HasKey(o, key)
  926.   PyObject *o;
  927.   PyObject *key;
  928. {
  929.   PyObject *v;
  930.  
  931.   v=PyObject_GetItem(o,key);
  932.   if(v) return 1;
  933.   PyErr_Clear();
  934.   return 0;
  935. }
  936.  
  937. PyObject *
  938. PyObject_CallObject(o, a)
  939.   PyObject *o, *a;
  940. {
  941.   PyObject *r;
  942.  
  943.   if(a) return PyEval_CallObject(o,a);
  944.  
  945.   if(! (a=PyTuple_New(0)))
  946.     return NULL;
  947.   r=PyEval_CallObject(o,a);
  948.   Py_DECREF(a);
  949.   return r;
  950. } 
  951.  
  952. PyObject *
  953. #ifdef HAVE_STDARG_PROTOTYPES
  954. /* VARARGS 2 */
  955. PyObject_CallFunction(PyObject *callable, char *format, ...)
  956. #else
  957. /* VARARGS */
  958. PyObject_CallFunction(va_alist) va_dcl
  959. #endif
  960. {
  961.   va_list va;
  962.   PyObject *args, *retval;
  963. #ifdef HAVE_STDARG_PROTOTYPES
  964.   va_start(va, format);
  965. #else
  966.   PyObject *callable;
  967.   char *format;
  968.   va_start(va);
  969.   callable = va_arg(va, PyObject *);
  970.   format   = va_arg(va, char *);
  971. #endif
  972.  
  973.   if( ! callable)
  974.     {
  975.       va_end(va);
  976.       return Py_ReturnNullError();
  977.     }
  978.  
  979.   if(format)
  980.     args = Py_VaBuildValue(format, va);
  981.   else
  982.     args = PyTuple_New(0);
  983.   
  984.   va_end(va);
  985.   if(! args) return NULL;
  986.  
  987.   if(! PyTuple_Check(args))
  988.     {
  989.       PyObject *a;
  990.       
  991.       Py_TRY(a=PyTuple_New(1));
  992.       Py_TRY(PyTuple_SetItem(a,0,args) != -1);
  993.       args=a;
  994.     }
  995.   retval = PyObject_CallObject(callable,args);
  996.   Py_DECREF(args);
  997.   return retval;
  998. }
  999.  
  1000. PyObject *
  1001. #ifdef HAVE_STDARG_PROTOTYPES
  1002. /* VARARGS 2 */
  1003. PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
  1004. #else
  1005. /* VARARGS */
  1006. PyObject_CallMethod(va_alist) va_dcl
  1007. #endif
  1008. {
  1009.   va_list va;
  1010.   PyObject *args, *meth=0, *retval;
  1011. #ifdef HAVE_STDARG_PROTOTYPES
  1012.   va_start(va, format);
  1013. #else
  1014.   PyObject *o;
  1015.   char *name;
  1016.   char *format;
  1017.   va_start(va);
  1018.   o      = va_arg(va, PyObject *);
  1019.   name   = va_arg(va, char *);
  1020.   format = va_arg(va, char *);
  1021. #endif
  1022.  
  1023.   if( ! o || ! name)
  1024.     {
  1025.       va_end(va);
  1026.       return Py_ReturnNullError();
  1027.     }
  1028.  
  1029.   meth=PyObject_GetAttrString(o,name);
  1030.   if(! meth)
  1031.     {
  1032.       va_end(va);
  1033.       PyErr_SetString(PyExc_AttributeError,name);
  1034.       return 0;
  1035.     }
  1036.    
  1037.   if(! (PyCallable_Check(meth)))
  1038.     {
  1039.       va_end(va);
  1040.       PyErr_SetString(PyExc_TypeError,"call of non-callable attribute");
  1041.       return 0;
  1042.     }
  1043.  
  1044.   if(format && *format)
  1045.     args = Py_VaBuildValue(format, va);
  1046.   else
  1047.     args = PyTuple_New(0);
  1048.   
  1049.   va_end(va);
  1050.  
  1051.   if(! args) return NULL;
  1052.  
  1053.   if(! PyTuple_Check(args))
  1054.     {
  1055.       PyObject *a;
  1056.       
  1057.       Py_TRY(a=PyTuple_New(1));
  1058.       Py_TRY(PyTuple_SetItem(a,0,args) != -1);
  1059.       args=a;
  1060.     }
  1061.  
  1062.   retval = PyObject_CallObject(meth,args);
  1063.   Py_DECREF(args);
  1064.   Py_DECREF(meth);
  1065.   return retval;
  1066. }
  1067.  
  1068. PyObject *
  1069. PyMapping_GetItemString(o, key)
  1070.   PyObject *o;
  1071.   char *key;
  1072. {
  1073.   PyObject *okey, *r;
  1074.  
  1075.   if( ! key) return Py_ReturnNullError();
  1076.   Py_TRY(okey=PyString_FromString(key));
  1077.   r = PyObject_GetItem(o,okey);
  1078.   Py_DECREF(okey);
  1079.   return r;
  1080. }
  1081.  
  1082. int
  1083. PyMapping_SetItemString(o, key, value)
  1084.  PyObject *o;
  1085.  char *key;
  1086.  PyObject *value;
  1087. {
  1088.   PyObject *okey;
  1089.   int r;
  1090.  
  1091.   if( ! key) return Py_ReturnNullError(),-1;
  1092.   if (!(okey=PyString_FromString(key))) return -1;
  1093.   r = PyObject_SetItem(o,okey,value);
  1094.   Py_DECREF(okey);
  1095.   return r;
  1096. }
  1097.